package com.writing.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.writing.entity.NovelGenre;
import com.writing.entity.User;
import com.writing.mapper.NovelGenreMapper;
import com.writing.service.NovelGenreService;
import com.writing.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 小说类型Service实现类
 */
@Service
@RequiredArgsConstructor
public class NovelGenreServiceImpl extends ServiceImpl<NovelGenreMapper, NovelGenre> implements NovelGenreService {

    private final UserService userService;

    @Override
    public List<NovelGenre> getGenresByUserId(Long userId) {
        List<NovelGenre> allGenres = new ArrayList<>();

        // 1. 获取用户自己的类型
        List<NovelGenre> userGenres = this.list(new LambdaQueryWrapper<NovelGenre>()
                .eq(NovelGenre::getUserId, userId)
                .eq(NovelGenre::getIsDefault, 0)
                .orderByDesc(NovelGenre::getCreatedAt));
        allGenres.addAll(userGenres);

        // 2. 获取管理员设置的默认类型（is_default=1 且创建者是管理员）
        List<Long> adminUserIds = userService.list(new LambdaQueryWrapper<User>()
                .eq(User::getRole, "ADMIN"))
                .stream()
                .map(User::getId)
                .collect(Collectors.toList());

        if (!adminUserIds.isEmpty()) {
            List<NovelGenre> adminDefaultGenres = this.list(new LambdaQueryWrapper<NovelGenre>()
                    .in(NovelGenre::getUserId, adminUserIds)
                    .eq(NovelGenre::getIsDefault, 1)
                    .orderByDesc(NovelGenre::getUsageCount)
                    .orderByDesc(NovelGenre::getUpdatedAt));
            allGenres.addAll(adminDefaultGenres);
        }

        return allGenres;
    }

    @Override
    public NovelGenre getGenreById(Long genreId, Long userId) {
        NovelGenre genre = this.getById(genreId);

        if (genre == null) {
            return null;
        }

        // 如果类型属于当前用户，直接返回
        if (genre.getUserId().equals(userId)) {
            return genre;
        }

        // 如果类型是管理员设置的默认类型，也允许普通用户查看
        User genreOwner = userService.getById(genre.getUserId());
        if (genreOwner != null && "ADMIN".equals(genreOwner.getRole())
            && genre.getIsDefault() != null && genre.getIsDefault() == 1) {
            return genre;
        }

        // 其他情况返回null（无权限）
        return null;
    }

    @Override
    public NovelGenre getGenreByCode(String code, Long userId) {
        // 首先查找用户自定义的类型
        NovelGenre userGenre = this.getOne(new LambdaQueryWrapper<NovelGenre>()
                .eq(NovelGenre::getCode, code)
                .eq(NovelGenre::getUserId, userId)
                .eq(NovelGenre::getIsDefault, 0));

        if (userGenre != null) {
            return userGenre;
        }

        // 如果没有用户自定义的，查找管理员设置的默认类型
        List<Long> adminUserIds = userService.list(new LambdaQueryWrapper<User>()
                .eq(User::getRole, "ADMIN"))
                .stream()
                .map(User::getId)
                .collect(Collectors.toList());

        if (!adminUserIds.isEmpty()) {
            NovelGenre adminDefaultGenre = this.getOne(new LambdaQueryWrapper<NovelGenre>()
                    .eq(NovelGenre::getCode, code)
                    .in(NovelGenre::getUserId, adminUserIds)
                    .eq(NovelGenre::getIsDefault, 1));
            if (adminDefaultGenre != null) {
                return adminDefaultGenre;
            }
        }

        return null;
    }

    @Override
    public NovelGenre createGenre(NovelGenre genre) {
        // 检查代码是否已存在
        NovelGenre existingGenre = getGenreByCode(genre.getCode(), genre.getUserId());
        if (existingGenre != null) {
            throw new RuntimeException("类型代码已存在");
        }

        // 设置默认值
        if (genre.getIsDefault() == null) {
            genre.setIsDefault(0); // 0表示非默认，1表示默认
        }
        if (genre.getUsageCount() == null) {
            genre.setUsageCount(0);
        }

        this.save(genre);
        return genre;
    }

    @Override
    public NovelGenre updateGenre(NovelGenre genre) {
        NovelGenre existingGenre = this.getById(genre.getId());

        if (existingGenre == null) {
            throw new RuntimeException("类型不存在");
        }

        // 检查权限：只有类型的所有者才能修改
        if (!existingGenre.getUserId().equals(genre.getUserId())) {
            throw new RuntimeException("无权限修改此类型");
        }

        // 检查是否是默认类型（普通用户不能修改默认类型，无论创建者是谁）
        User currentUser = userService.getById(genre.getUserId());
        if (currentUser != null && !"ADMIN".equals(currentUser.getRole())) {
            // 普通用户不能修改默认类型
            if (existingGenre.getIsDefault() != null && existingGenre.getIsDefault() == 1) {
                throw new RuntimeException("不能修改默认类型");
            }
        }

        // 默认类型不允许修改代码
        if (existingGenre.getIsDefault() == 1 && !existingGenre.getCode().equals(genre.getCode())) {
            throw new RuntimeException("默认类型不允许修改代码");
        }

        // 检查代码是否与其他类型冲突
        if (!existingGenre.getCode().equals(genre.getCode())) {
            NovelGenre conflictGenre = getGenreByCode(genre.getCode(), genre.getUserId());
            if (conflictGenre != null) {
                throw new RuntimeException("类型代码已存在");
            }
        }

        // 保留原有的使用次数和默认状态
        genre.setUsageCount(existingGenre.getUsageCount());
        if (genre.getIsDefault() == null) {
            genre.setIsDefault(existingGenre.getIsDefault());
        }

        this.updateById(genre);
        return genre;
    }

    @Override
    public boolean deleteGenre(Long genreId, Long userId) {
        NovelGenre genre = this.getById(genreId);

        if (genre == null) {
            throw new RuntimeException("类型不存在");
        }

        // 检查权限：只有类型的所有者才能删除
        if (!genre.getUserId().equals(userId)) {
            throw new RuntimeException("无权限删除此类型");
        }

        // 检查是否是默认类型（普通用户不能删除默认类型，无论创建者是谁）
        User currentUser = userService.getById(userId);
        if (currentUser != null && !"ADMIN".equals(currentUser.getRole())) {
            // 普通用户不能删除默认类型
            if (genre.getIsDefault() != null && genre.getIsDefault() == 1) {
                throw new RuntimeException("不能删除默认类型");
            }
        }

        return this.removeById(genreId);
    }

    @Override
    public void initDefaultGenres(Long userId) {
        // 该方法已废弃，不再为每个用户复制类型
        // 现在默认类型由管理员在后台设置，所有用户都可以看到和使用
        // 保留此方法是为了兼容性，不做任何操作
        return;
    }

    @Override
    public List<NovelGenre> getDefaultGenres() {
        // 从数据库查询管理员设置的默认类型
        // 获取所有管理员用户ID
        List<Long> adminUserIds = userService.list(new LambdaQueryWrapper<User>()
                .eq(User::getRole, "ADMIN"))
                .stream()
                .map(User::getId)
                .collect(Collectors.toList());

        if (adminUserIds.isEmpty()) {
            return new ArrayList<>();
        }

        // 查询管理员创建的默认类型（is_default=1）
        LambdaQueryWrapper<NovelGenre> queryWrapper = new LambdaQueryWrapper<NovelGenre>()
                .in(NovelGenre::getUserId, adminUserIds)
                .eq(NovelGenre::getIsDefault, 1)
                .orderByDesc(NovelGenre::getUsageCount)
                .orderByDesc(NovelGenre::getUpdatedAt);

        return this.list(queryWrapper);
    }
}
